A modern general-purpose computer system uses an operating system (OS) to manage the hardware and software resources of the computer. The OS is a software program that performs basic tasks, such as controlling and allocating memory, prioritizing the processing of instructions, controlling input and output devices, facilitating networking, and managing files. The OS also provides application program interfaces (APIs or interfaces) to enable the application programs (applications) to interact with the hardware and software resources as well as with other application programs.
An application, as well as one or more libraries which are linked either statically or dynamically to the application, may use supplemental code (e.g., plug-ins) to perform certain functionality that the application and the libraries have not been programmed to perform. A plug-in is a code module that is not part of the application or library, but which can be accessed by the application or library to extend its respective functionality. Although a variety of different plug-ins exist, a typical example may include a plug-in that provides display capabilities for a certain graphics format that a web browsing application does not support natively. The application typically provides a way for a plug-in to register with the application, and the application and the plug-in provide respective interfaces via which data is exchanged between the application and the plug-in. Other types of supplemental code are also possible.
The circumstance and terminology of an application “crashing” is well-known to those familiar with computers and with the art of computer programming. As used herein, the term “crash” will refer to any instance in which the execution of the application is halted abnormally, whether as a result of the application freezing, or as a result of the application aborting. In such cases, an application will unexpectedly (not in response to system or user control) cease normal execution of its instructions.
The aforementioned variety of plug-ins may be provided by different developers. More specifically, plug-ins may be provided by the OS developer, the application developer or any other third party developer. Although it is possible that plug-ins provided by the OS developer and by the application developer may cause the application to crash, the more typical case arises when a crash of the application is caused by a plug-in of a third party developer (e.g., developer other than the OS developer and application developer). This occurs in part because the OS developer and the application developer cannot typically test the OS or the application against all third party plug-ins. For example, an application crash may be caused because the third-party authored plug-ins may use application program interfaces (APIs) that are not authorized or documented by the developer of the application or by the developer of the OS and these unauthorized or undocumented APIs may behave differently in newer versions of the OS or application. Similarly, an application may inadvertently rely on undocumented or unsupported APIs in a plug-in and newer versions of that plug-in may remove or change these APIs in such a way that may cause an application crash. It is also noted that generic programming errors in the plug-in may also cause the application to crash.
In such circumstances, determination of which plug-in has caused the application to crash is important in order for a user to take appropriate corrective action. Certain applications (e.g., crash reporters) exist which provide the user with a description of why the application has crashed. However, it is often difficult for most users to determine information from crash reporters. In particular, it is typically difficult for the user to determine whether the application has crashed because of a plug-in, and if so, to identify the offending plug-in. Furthermore, it is often difficult for the user to take appropriate corrective action to make sure that the application does not crash again.